// 在文件开头添加以下代码
chrome.sidePanel.setPanelBehavior({ openPanelOnActionClick: true });

// 其余代码保持不变
// 存储店铺信息
let shopInfo = null;
let tempAntiContent = '';
// 添加验证状态变量
let authStatus = false;
let lastAuthTime = 0;
const AUTH_INTERVAL = 20000; // 20秒验证一次
// 监听来自弹出窗口的消息
// ... existing code ...


chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
  console.log('bg收到消息:', request);
  // 添加验证请求处理
  if (request.action === 'verifyAuth') {
    verifyAuth(request.forceCheck)
      .then(response => sendResponse(response))
      .catch(error => sendResponse({ success: false, error: error.message }));
    return true;
  }
  
  // 如果不是验证请求，检查当前验证状态
  else if (request.action !== 'checkAuthStatus' && !authStatus) {
    sendResponse({ success: false, error: '未通过验证，请重新登录' });
    return true;
  }
  
  // 检查验证状态的请求
  else if (request.action === 'checkAuthStatus') {
    sendResponse({ success: true, authStatus: authStatus });
    return true;
  }
  else if (request.action === 'startRegistration') {
    handleRegistration(request.activityUrl, request.minPrice,request.priceType,request.priceData,request.activityStock)
      .then(response => sendResponse(response))
      .catch(error => sendResponse({ success: false, error: error.message }));
    return true;
  } // 在 getShopInfo 处理部分添加主动获取用户信息的逻辑
else if (request.action === 'getShopInfo') {
  // 如果已经有店铺信息，直接返回
  //if (shopInfo) {
    //console.log('已有店铺信息，直接返回:', shopInfo);
    //sendResponse({ success: true, shopInfo: shopInfo });
    //return true;
 // }

  
  // 没有店铺信息，尝试主动获取
  console.log('没有店铺信息，尝试主动获取');
  
  // 获取当前活动标签页
  chrome.tabs.query({active: true, currentWindow: true}, function(tabs) {
    if (tabs && tabs.length > 0) {
      const tab = tabs[0];
      let hasResponded = false;
    
    // Function to safely send response only once
    const safeResponse = (response) => {
      if (!hasResponded) {
        hasResponded = true;
        sendResponse(response);
      }
    };
    
      setTimeout(async () => {
        try {
          await chrome.scripting.executeScript({
            target: {tabId: tab.id},
            files: ['content.js']
          });
          console.log('bg开始fetchUserInfo')
            // 向内容脚本发送获取用户信息的消息
            chrome.tabs.sendMessage(tab.id, {
              action: 'fetchUserInfo',
              antiContent: tempAntiContent || '', // 修改这里
              newMallid:request.newMallId ||''
            }, (response) => {
              if (chrome.runtime.lastError) {
                console.log('发送消息时出错:', chrome.runtime.lastError.message);
                // 继续执行，不要抛出错误
              } else {
                console.log('已发送fetchUserInfo消息到content.js');
              }
              // 这里不需要处理response，因为content.js会通过另一个消息返回结果
            });
    } catch (error) {
      console.error('注入content.js失败:', error);
      safeResponse({ success: false, error: '无法注入内容' });
    }
    }, 2000);
    setTimeout(() => {
      if (shopInfo) {
        safeResponse({ success: true, shopInfo: shopInfo });
      } else {
        safeResponse({ success: false, error: '获取店铺信息超时' });
      }
    }, 10000);
    
    return true; // 保持异步响应开放
      
    } else {
      sendResponse({ success: false, error: '未找到标签页' });
    }
  });
  
  // 设置超时，确保即使没有收到响应也会返回结果
 
} else if (request.action === 'updateStatus') {
  // 转发状态更新消息到所有页面
  chrome.runtime.sendMessage({
    action: 'updateStatus',
    message: request.message
  });
}
else if(request.action ==='fetchActivityProducts'){
  fetchProductsPaget(request.url,request.data,sender)
      .then(response => sendResponse(response))
      .catch(error => sendResponse({ success: false, error: error.message }));
    return true;
}
else if(request.action ==='fetchActivityList'){
  fetchActivityList(request.url,sender)
      .then(response => sendResponse(response))
      .catch(error => sendResponse({ success: false, error: error.message }));
    return true;
}
 else {
    sendResponse({ success: false, error: '未知的action类型' });
  }
  return true;
});

// ... existing webRequest listener code ...

// 处理获取店铺信息的消息
// 获取活动商品数据
// 添加验证函数
async function verifyAuth(forceCheck = false) {
    console.log('本地存储的授权2信息:', authInfo);
    // 有token则认为验证通过
    authStatus = true;
    return { success: true, authStatus: true };
}

// 处理登录请求


// 添加一个安全的消息广播函数
function safelyBroadcastMessage(message) {
  console.log('广播消息:', message);
  setTimeout(async () => {
    try {
      // 只向特定域名的标签页发送消息
      const tabs = await chrome.tabs.query({
        url: ["*://*.temu.com/*"]
      });

      for (const tab of tabs) {
        try {
          // 检查标签页是否可以注入脚本
          const [{ result }] = await chrome.scripting.executeScript({
            target: { tabId: tab.id },
            func: () => true,
          }).catch(() => [{ result: false }]);
console.log('是否可以注入:', result);
          if (result) {
            // 如果可以注入，则注入content.js
            await chrome.scripting.executeScript({
              target: { tabId: tab.id },
              files: ['content.js']
            });

            // 等待一小段时间确保content.js加载完成
            await new Promise(resolve => setTimeout(resolve, 500));

            // 发送消息
            await new Promise(resolve => {
              chrome.tabs.sendMessage(tab.id, message, response => {
                if (chrome.runtime.lastError) {
                  console.log(`向标签 ${tab.id} 发送消息失败: ${chrome.runtime.lastError.message}`);
                }
                resolve();
              });
            });
          }
        } catch (error) {
          console.log(`处理标签 ${tab.id} 时出现异常:`, error);
        }
      }
       // 2. 向扩展页面广播消息
       chrome.runtime.sendMessage(message);
    } catch (error) {
      console.error('广播消息处理出错:', error);
    }
  }, 1000);
}
// 启动时进行一次验证
// 先初始化，然后再进行验证
// 修改初始化验证逻辑
async function initializeAuthStatus() {
      console.log('从本地存储恢复登录状态');
      authStatus = true;
}
// 启动时执行初始化
//initializeAuthStatus();
 verifyAuth(true).then(result => {
   console.log('初始验证结果:', result);
});
// 设置定时验证
//setInterval(() => {
 // verifyAuth(true).then(result => {
  //  console.log('定时验证结果:', result);
  //});
//}, AUTH_INTERVAL);

async function fetchProductsPaget(url, data,sender) {
  console.log('获取活动商品数据 request:', url, data);
  try {
    // 尝试使用发送消息的标签页
    if (sender && sender.tab && sender.tab.id) {
      console.log('使用发送消息的标签页:', sender.tab.id);
      const tabId = sender.tab.id;
      
      // 确保content.js已注入
      await chrome.scripting.executeScript({
        target: {tabId: tabId},
        files: ['content.js']
      });
      
      // 向content.js发送请求
      return new Promise((resolve, reject) => {
        chrome.tabs.sendMessage(tabId, {
          action: 'fetchProductsPageFromContent',
          url: url,
          data: data,
          antiContent: tempAntiContent || ''
        }, response => {
          console.log('获取活动商品数据 response:', response ? JSON.stringify(response) : 'null');
          if (chrome.runtime.lastError) {
            console.error('发送消息错误:', chrome.runtime.lastError);
            reject(chrome.runtime.lastError);
          } else if (!response) {
            reject(new Error('未收到内容脚本响应，请刷新页面后重试'));
          } else if (response.error) {
            reject(new Error(response.error));
          } else {
            resolve(response);
          }
        });
      });
    } else {
      // 如果没有发送者标签页，尝试使用最近使用的标签页
      console.log('尝试使用最近使用的标签页...');
      const tabs = await new Promise(resolve => {
        chrome.tabs.query({active: true, lastFocusedWindow: true}, tabs => {
          console.log('最近使用的标签页:', tabs);
          resolve(tabs);
        });
      });
      
      if (tabs && tabs.length > 0) {
        const tab = tabs[0];
        console.log('使用最近使用的标签页:', tab.url);
        
        // 确保content.js已注入
        await chrome.scripting.executeScript({
          target: {tabId: tab.id},
          files: ['content.js']
        });
        
        // 向content.js发送请求
        return new Promise((resolve, reject) => {
          chrome.tabs.sendMessage(tab.id, {
            action: 'fetchProductsPageFromContent',
            url: url,
            data: data,
            antiContent: tempAntiContent || ''
          }, response => {
            console.log('获取活动商品数据 response:', response ? JSON.stringify(response) : 'null');
            if (chrome.runtime.lastError) {
              console.error('发送消息错误:', chrome.runtime.lastError);
              reject(chrome.runtime.lastError);
            } else if (!response) {
              reject(new Error('未收到内容脚本响应，请刷新页面后重试'));
            } else if (response.error) {
              reject(new Error(response.error));
            } else {
              resolve(response);
            }
          });
        });
      } else {
        throw new Error('未找到可用的标签页，请确保有一个快竞猫网站的标签页处于打开状态');
      }
    }
  } catch (error) {
    console.error('获取活动商品数据失败:', error);
    throw error;
  }
}

// 获取活动列表数据
async function fetchActivityList(url, sender) {
 //  console.log('获取活动列表数据 request:', url);
  try {
    // 尝试使用发送消息的标签页
    if (sender && sender.tab && sender.tab.id) {
      console.log('使用发送消息的标签页:', sender.tab.id);
      const tabId = sender.tab.id;
      
      // 确保content.js已注入
      await chrome.scripting.executeScript({
        target: {tabId: tabId},
        files: ['content.js']
      });
      
      // 向content.js发送请求
      return new Promise((resolve, reject) => {
        chrome.tabs.sendMessage(tabId, {
          action: 'fetchActivityListFromContent',
          url: url,
          antiContent: tempAntiContent || ''
        }, response => {
         // console.log('获取活动列表数据 response:', response ? JSON.stringify(response) : 'null');
          if (chrome.runtime.lastError) {
            console.error('发送消息错误:', chrome.runtime.lastError);
            reject(chrome.runtime.lastError);
          } else if (!response) {
            reject(new Error('未收到内容脚本响应，请刷新页面后重试'));
          } else if (response.error) {
            reject(new Error(response.error));
          } else {
            resolve(response);
          }
        });
      });
    } else {
      // 如果没有发送者标签页，尝试使用最近使用的标签页
      console.log('尝试使用最近使用的标签页...');
      const tabs = await new Promise(resolve => {
        chrome.tabs.query({active: true, lastFocusedWindow: true}, tabs => {
          console.log('最近使用的标签页:', tabs);
          resolve(tabs);
        });
      });
      
      if (tabs && tabs.length > 0) {
        const tab = tabs[0];
        console.log('使用最近使用的标签页:', tab.url);
        
        // 确保content.js已注入
        await chrome.scripting.executeScript({
          target: {tabId: tab.id},
          files: ['content.js']
        });
        
        // 向content.js发送请求
        return new Promise((resolve, reject) => {
          chrome.tabs.sendMessage(tab.id, {
            action: 'fetchActivityListFromContent',
            url: url,
            antiContent: tempAntiContent || ''
          }, response => {
            //console.log('获取活动列表数据 response:', response ? JSON.stringify(response) : 'null');
            if (chrome.runtime.lastError) {
              console.error('发送消息错误:', chrome.runtime.lastError);
              reject(chrome.runtime.lastError);
            } else if (!response) {
              reject(new Error('未收到内容脚本响应，请刷新页面后重试'));
            } else if (response.error) {
              reject(new Error(response.error));
            } else {
              resolve(response);
            }
          });
        });
      } else {
        throw new Error('未找到可用的标签页，请确保有一个快竞猫网站的标签页处于打开状态');
      }
    }
  } catch (error) {
    console.error('获取活动列表数据失败:', error);
    throw error;
  }
}

// 处理活动报名流程
async function handleRegistration(activityUrl, minPrice,priceType,priceData,activityStock) {
  try {
    console.log('报名活动链接:', activityUrl);
    
    const urlParams = new URL(activityUrl).searchParams;
    const activityId = urlParams.get('thematicId');
    const activityType = urlParams.get('type');
    console.log('活动 ID:', activityId);
    if (!activityId ||!activityType   || !activityUrl.includes('temu.com')) {
      throw new Error('无效的temu活动链接');
    }
    if (!priceType) {
      throw new Error('请选择价格设置方式');
    }
    
    // 验证价格数据
    if (priceType === '1' && !minPrice) {
      throw new Error('请输入固定价格');
    }
    
    if (priceType === '2' && (!priceData.minRandomPrice || !priceData.maxRandomPrice)) {
      throw new Error('请输入完整的价格区间');
    }
// 添加延迟，等待页面加载完成
  await new Promise(resolve => setTimeout(resolve, 5000));


    // 向活动页面注入内容脚本
    const tabs = await new Promise((resolve) => {
      chrome.tabs.query({ active: true }, (tabs) => {
        resolve(tabs);
      });
    });



   

    console.log('活动页面标签:', tabs);
    
    if (!tabs || tabs.length === 0) {
      throw new Error('未找到活动页面标签');
    }
    const tab = tabs[0];
    
     // 修改为使用scripting API
     await chrome.scripting.executeScript({
      target: {tabId: tab.id},
      files: ['content.js']
    });

    // 发送活动ID到内容脚本
    await chrome.tabs.sendMessage(tab.id, {
      action: 'initRegistration',
      activityId: activityId,
      activityType: activityType,
      minPrice: minPrice,
      priceType:priceType,
      priceData:priceData,
      activityStock: activityStock,
      antiContent: tempAntiContent || '' // 修改这里
    }).catch(error => {
      console.log('发送initRegistration消息失败:', error);
      // 继续执行，不要抛出错误
    });

    return { success: true };
  } catch (error) {
    console.error('Registration error:', error);
    return { success: false, error: error.message };
  }
};
// 存储店铺信息


// 直接发送POST请求到userInfo接口
// ... existing code ...


// ... existing code ...


// 监听响应
// 监听浏览器的网络请求事件
console.log('注册网络请求监听器')
// 添加一个变量来记录上次请求的时间
let lastUserInfoRequestTime = 0;
const USER_INFO_REQUEST_INTERVAL = 60000; // 设置最小请求间隔为60秒
// 添加一个标志变量，表示是否已经请求过
let userInfoRequested = false;
// 添加onBeforeSendHeaders监听器获取请求头
chrome.webRequest.onBeforeSendHeaders.addListener(
  function(details) {
  
    if (details.url.includes('/bg/quiet/api/mms/userInfo') || details.url.includes('/api/seller/auth/userInfo')) {
      console.log('onBeforeSendHeaders捕获到userInfo请求:', details.url);
      // 存储请求头信息供后续使用
      const antiContentHeader = details.requestHeaders.find(h => h.name.toLowerCase() === 'anti-content');
      if (antiContentHeader && !userInfoRequested) {
        console.log('捕获到Anti-Content:', antiContentHeader.value);
        // 临时存储anti-content值
        tempAntiContent = antiContentHeader.value; // 修改这里
        // 标记为已请求
        userInfoRequested = true;
        
         // 获取当前标签页，并在内容脚本中执行请求
         chrome.tabs.query({active: true, currentWindow: true}, function(tabs) {
          if (tabs && tabs.length > 0) {
            chrome.tabs.sendMessage(tabs[0].id, {
              action: 'fetchUserInfo',
              antiContent: antiContentHeader.value
            }, function(response) {
              if (chrome.runtime.lastError) {
                console.log('发送fetchUserInfo消息失败:', chrome.runtime.lastError.message);
              }
            });
          }
        });
      }
    }
    return {requestHeaders: details.requestHeaders};
  },
  {urls: ["*://*.kuajingmaihuo.com/*", "*://*.temu.com/*"]},
  ["requestHeaders", "extraHeaders"]
);
// 存储响应数据的Map
// 直接发送POST请求到userInfo接口


// 监听来自内容脚本的用户信息响应
chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
  if (request.action === 'userInfoResponse') {
    console.log('收到用户信息响应:', request.data);
    console.log('收到用户信息响应的新mallid:', request.newMallid);
    const newMallId=request.newMallid ||''
    // 处理响应数据
    if (request.data.success && request.data.result && (request.data.result.companyList || request.data.result.mallList)) {
      let mallInfo;
  // 根据当前页面URL判断数据结构
     const isTemu = sender.tab.url.includes('temu.com');
     console.log('是否temu:', isTemu);
     
      if(newMallId){
        if (isTemu) {
          // Temu的数据结构处理
          const shopList = request.data.result.mallList;
          if (Array.isArray(shopList)) {
            mallInfo = shopList.find(mall => mall.mallId.toString() === newMallId.toString());
          }
          }
           else {
        const malInfoList = request.data.result.companyList[0]?.malInfoList;
        if (Array.isArray(malInfoList)) {
          mallInfo = malInfoList.find(mall => mall.mallId.toString() === newMallId.toString());
        }
      }
        if (!mallInfo) {
          console.error('找不到指定ID的商店信息:', newMallId);
        }
     
        //收到用户信息响应的新mallid: 634418222601734
      }
      else{
         // 默认选择第一个店铺
         if (isTemu) {
          mallInfo = request.data.result.mallList[0];
        } else {
        mallInfo= request.data.result.companyList[0]?.malInfoList[0];
        }
      }
      
      console.log('Mall Info:', mallInfo);
      
      if (mallInfo) {
        const newShopInfo = {
          mallName: mallInfo.mallName,
          mallId: mallInfo.mallId,
          antiContent: tempAntiContent // 修改这里
        };
        
        // 检查shopInfo是否真正发生变化
        const hasChanged = !shopInfo || 
          shopInfo.mallName !== newShopInfo.mallName ||
          shopInfo.mallId !== newShopInfo.mallId ||
          shopInfo.antiContent !== newShopInfo.antiContent;

        //if (hasChanged) {
          shopInfo = newShopInfo;
          console.log('ShopInfo已更新:', shopInfo);
          // 使用安全的消息广播函数
          safelyBroadcastMessage({
            action: 'updateShopInfo',
            shopInfo: shopInfo
          });
       // } else {
         // console.log('ShopInfo未发生变化，跳过更新');
       // }
      }
    }
  }
  // ... 其他消息处理 ...
});

